package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:33
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductGlossaryRelateDAOQueryBean extends BaseQueryBean {
    public ProductGlossaryRelateDAOQueryBean() {
        super();
    }

    public ProductGlossaryRelateDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductGlossaryRelateDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.Id, "id");
        }
    }

    public void addProductDefineIdSelectProperty() {
        addProductDefineIdSelectProperty("productDefineId");
    }

    public void addProductDefineIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.ProductDefineId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.ProductDefineId,
                "productDefineId");
        }
    }

    public void addProductGlossaryIdSelectProperty() {
        addProductGlossaryIdSelectProperty("productGlossaryId");
    }

    public void addProductGlossaryIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.ProductGlossaryId,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.ProductGlossaryId,
                "productGlossaryId");
        }
    }

    public void addRelatedProductGlossaryIdSelectProperty() {
        addRelatedProductGlossaryIdSelectProperty("relatedProductGlossaryId");
    }

    public void addRelatedProductGlossaryIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedProductGlossaryId,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedProductGlossaryId,
                "relatedProductGlossaryId");
        }
    }

    public void addRelatedTypeSelectProperty() {
        addRelatedTypeSelectProperty("relatedType");
    }

    public void addRelatedTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedType, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedType,
                "relatedType");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.Status, "status");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.Remarks, "remarks");
        }
    }

    public void addRelatedNameSelectProperty() {
        addRelatedNameSelectProperty("relatedName");
    }

    public void addRelatedNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedName, aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedName,
                "relatedName");
        }
    }

    public void addRelatedGlossaryCodeSelectProperty() {
        addRelatedGlossaryCodeSelectProperty("relatedGlossaryCode");
    }

    public void addRelatedGlossaryCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedGlossaryCode,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedGlossaryCode,
                "relatedGlossaryCode");
        }
    }

    public void addRelatedGlossaryNameSelectProperty() {
        addRelatedGlossaryNameSelectProperty("relatedGlossaryName");
    }

    public void addRelatedGlossaryNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedGlossaryName,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryRelateDAO.RelatedGlossaryName,
                "relatedGlossaryName");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addProductDefineIdSelectProperty();

        addProductGlossaryIdSelectProperty();

        addRelatedProductGlossaryIdSelectProperty();

        addRelatedTypeSelectProperty();

        addStatusSelectProperty();

        addRemarksSelectProperty();

        addRelatedNameSelectProperty();

        addRelatedGlossaryCodeSelectProperty();

        addRelatedGlossaryNameSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductGlossaryRelateDAOQueryBean> {
        protected Criteria(ProductGlossaryRelateDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductGlossaryRelateDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.Id + " is not null AND " +
                IProductGlossaryRelateDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.Id + " is null OR " +
                IProductGlossaryRelateDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " is null OR " +
                IProductGlossaryRelateDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Id + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andProductDefineIdIsNull() {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " is null");

            return this;
        }

        public Criteria andProductDefineIdIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " is not null");

            return this;
        }

        public Criteria andProductDefineIdIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " is not null AND " +
                IProductGlossaryRelateDAO.ProductDefineId + " <> ''");

            return this;
        }

        public Criteria andProductDefineIdIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.ProductDefineId +
                " is null OR " + IProductGlossaryRelateDAO.ProductDefineId +
                " = '')");

            return this;
        }

        public Criteria andProductDefineIdEqualTo(long value) {
            return andProductDefineIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " = ",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(long value) {
            return andProductDefineIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " <>",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(long value) {
            return andProductDefineIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " is null OR " + IProductGlossaryRelateDAO.ProductDefineId +
                " <>", value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(long value) {
            return andProductDefineIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " >",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(long value) {
            return andProductDefineIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " >=",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThan(long value) {
            return andProductDefineIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " <",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(long value) {
            return andProductDefineIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " <=",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductDefineId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                    " not in", values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                    " not in", values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                    " not in", Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " not between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductDefineId +
                " not between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductGlossaryIdIsNull() {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " is null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " is not null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " is not null AND " +
                IProductGlossaryRelateDAO.ProductGlossaryId + " <> ''");

            return this;
        }

        public Criteria andProductGlossaryIdIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryRelateDAO.ProductGlossaryId +
                " = '')");

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(long value) {
            return andProductGlossaryIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " = ",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(long value) {
            return andProductGlossaryIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " <>",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(long value) {
            return andProductGlossaryIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryRelateDAO.ProductGlossaryId +
                " <>", value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(long value) {
            return andProductGlossaryIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " >",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(long value) {
            return andProductGlossaryIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " >=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(long value) {
            return andProductGlossaryIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " <",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(long value) {
            return andProductGlossaryIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " <=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.ProductGlossaryId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " in", Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                    " not in", Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdIsNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " is null");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " is not null");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " is not null AND " +
                IProductGlossaryRelateDAO.RelatedProductGlossaryId + " <> ''");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdIsEmpty() {
            addCriterion("(" +
                IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " is null OR " +
                IProductGlossaryRelateDAO.RelatedProductGlossaryId + " = '')");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdEqualTo(long value) {
            return andRelatedProductGlossaryIdEqualTo(Long.valueOf(value));
        }

        public Criteria andRelatedProductGlossaryIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " = ", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotEqualTo(long value) {
            return andRelatedProductGlossaryIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andRelatedProductGlossaryIdNotEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " <>", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotEqualToOrIsNull(
            long value) {
            return andRelatedProductGlossaryIdNotEqualToOrIsNull(Long.valueOf(
                    value));
        }

        public Criteria andRelatedProductGlossaryIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " is null OR " +
                IProductGlossaryRelateDAO.RelatedProductGlossaryId + " <>",
                value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThan(long value) {
            return andRelatedProductGlossaryIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andRelatedProductGlossaryIdGreaterThan(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " >", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThanOrEqualTo(
            long value) {
            return andRelatedProductGlossaryIdGreaterThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andRelatedProductGlossaryIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " >=", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThan(long value) {
            return andRelatedProductGlossaryIdLessThan(Long.valueOf(value));
        }

        public Criteria andRelatedProductGlossaryIdLessThan(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " <", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThanOrEqualTo(long value) {
            return andRelatedProductGlossaryIdLessThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andRelatedProductGlossaryIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " <=", value, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedProductGlossaryId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedProductGlossaryIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdIn(long[] values) {
            if (values.length == 1) {
                return andRelatedProductGlossaryIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " in", values, "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdNotIn(long[] values) {
            if (values.length == 1) {
                return andRelatedProductGlossaryIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " not in", values, "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andRelatedProductGlossaryIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " in", values, "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdNotIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andRelatedProductGlossaryIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " not in", values, "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andRelatedProductGlossaryIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " in", Arrays.asList(values), "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdNotIn(
            java.lang.Long[] values) {
            if (values.length == 1) {
                return andRelatedProductGlossaryIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                    " not in", Arrays.asList(values), "relatedProductGlossaryId");

                return this;
            }
        }

        public Criteria andRelatedProductGlossaryIdIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedProductGlossaryIdBetween(long value1,
            long value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " between", value1, value2, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " between", value1, value2, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotBetween(long value1,
            long value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " not between", value1, value2, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedProductGlossaryIdNotBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedProductGlossaryId +
                " not between", value1, value2, "relatedProductGlossaryId");

            return this;
        }

        public Criteria andRelatedTypeIsNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " is null");

            return this;
        }

        public Criteria andRelatedTypeIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedType +
                " is not null");

            return this;
        }

        public Criteria andRelatedTypeIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.RelatedType +
                " is not null AND " + IProductGlossaryRelateDAO.RelatedType +
                " <> ''");

            return this;
        }

        public Criteria andRelatedTypeIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.RelatedType +
                " is null OR " + IProductGlossaryRelateDAO.RelatedType +
                " = '')");

            return this;
        }

        public Criteria andRelatedTypeEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " = ", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " <>", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType +
                " is null OR " + IProductGlossaryRelateDAO.RelatedType + " <>",
                value, "relatedType");

            return this;
        }

        public Criteria andRelatedTypeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " >", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " >=", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " <", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " <=", value,
                "relatedType");

            return this;
        }

        public Criteria andRelatedTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " like",
                buffer.toString(), "relatedType");

            return this;
        }

        public Criteria andRelatedTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " not like",
                buffer.toString(), "relatedType");

            return this;
        }

        public Criteria andRelatedTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedType + " in",
                    values, "relatedType");

                return this;
            }
        }

        public Criteria andRelatedTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedType + " not in",
                    values, "relatedType");

                return this;
            }
        }

        public Criteria andRelatedTypeIn(String[] values) {
            if (values.length == 1) {
                return andRelatedTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedType + " in",
                    Arrays.asList(values), "relatedType");

                return this;
            }
        }

        public Criteria andRelatedTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andRelatedTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedType + " not in",
                    Arrays.asList(values), "relatedType");

                return this;
            }
        }

        public Criteria andRelatedTypeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedTypeBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType + " between",
                value1, value2, "relatedType");

            return this;
        }

        public Criteria andRelatedTypeNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedType +
                " not between", value1, value2, "relatedType");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductGlossaryRelateDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.Status +
                " is not null AND " + IProductGlossaryRelateDAO.Status +
                " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.Status +
                " is null OR " + IProductGlossaryRelateDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " = ", value,
                "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " <>", value,
                "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " is null OR " +
                IProductGlossaryRelateDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " >", value,
                "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " >=", value,
                "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " <", value,
                "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Status + " <=", value,
                "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Status + " in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Status + " not in",
                    values, "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Status + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.Status + " not between",
                value1, value2, "status");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.Remarks +
                " is not null AND " + IProductGlossaryRelateDAO.Remarks +
                " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.Remarks +
                " is null OR " + IProductGlossaryRelateDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " = ", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " <>", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " is null OR " +
                IProductGlossaryRelateDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " >", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " >=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " <", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " <=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.Remarks + " not in",
                    values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.Remarks + " not between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andRelatedNameIsNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " is null");

            return this;
        }

        public Criteria andRelatedNameIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedName +
                " is not null");

            return this;
        }

        public Criteria andRelatedNameIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.RelatedName +
                " is not null AND " + IProductGlossaryRelateDAO.RelatedName +
                " <> ''");

            return this;
        }

        public Criteria andRelatedNameIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.RelatedName +
                " is null OR " + IProductGlossaryRelateDAO.RelatedName +
                " = '')");

            return this;
        }

        public Criteria andRelatedNameEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " = ", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " <>", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName +
                " is null OR " + IProductGlossaryRelateDAO.RelatedName + " <>",
                value, "relatedName");

            return this;
        }

        public Criteria andRelatedNameNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " >", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " >=", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " <", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " <=", value,
                "relatedName");

            return this;
        }

        public Criteria andRelatedNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " like",
                buffer.toString(), "relatedName");

            return this;
        }

        public Criteria andRelatedNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " not like",
                buffer.toString(), "relatedName");

            return this;
        }

        public Criteria andRelatedNameIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedName + " in",
                    values, "relatedName");

                return this;
            }
        }

        public Criteria andRelatedNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedName + " not in",
                    values, "relatedName");

                return this;
            }
        }

        public Criteria andRelatedNameIn(String[] values) {
            if (values.length == 1) {
                return andRelatedNameEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedName + " in",
                    Arrays.asList(values), "relatedName");

                return this;
            }
        }

        public Criteria andRelatedNameNotIn(String[] values) {
            if (values.length == 1) {
                return andRelatedNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedName + " not in",
                    Arrays.asList(values), "relatedName");

                return this;
            }
        }

        public Criteria andRelatedNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedNameBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName + " between",
                value1, value2, "relatedName");

            return this;
        }

        public Criteria andRelatedNameNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedName +
                " not between", value1, value2, "relatedName");

            return this;
        }

        public Criteria andRelatedGlossaryCodeIsNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " is null");

            return this;
        }

        public Criteria andRelatedGlossaryCodeIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " is not null");

            return this;
        }

        public Criteria andRelatedGlossaryCodeIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " is not null AND " +
                IProductGlossaryRelateDAO.RelatedGlossaryCode + " <> ''");

            return this;
        }

        public Criteria andRelatedGlossaryCodeIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " is null OR " + IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " = '')");

            return this;
        }

        public Criteria andRelatedGlossaryCodeEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " = ",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " <>",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " is null OR " + IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " <>", value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " >",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " >=",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " <",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode + " <=",
                value, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryCode);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryCodeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " like", buffer.toString(), "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " not like", buffer.toString(), "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedGlossaryCodeEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                    " in", values, "relatedGlossaryCode");

                return this;
            }
        }

        public Criteria andRelatedGlossaryCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedGlossaryCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                    " not in", values, "relatedGlossaryCode");

                return this;
            }
        }

        public Criteria andRelatedGlossaryCodeIn(String[] values) {
            if (values.length == 1) {
                return andRelatedGlossaryCodeEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                    " in", Arrays.asList(values), "relatedGlossaryCode");

                return this;
            }
        }

        public Criteria andRelatedGlossaryCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andRelatedGlossaryCodeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                    " not in", Arrays.asList(values), "relatedGlossaryCode");

                return this;
            }
        }

        public Criteria andRelatedGlossaryCodeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryCodeBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " between", value1, value2, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryCodeNotBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryCode +
                " not between", value1, value2, "relatedGlossaryCode");

            return this;
        }

        public Criteria andRelatedGlossaryNameIsNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " is null");

            return this;
        }

        public Criteria andRelatedGlossaryNameIsNotNull() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " is not null");

            return this;
        }

        public Criteria andRelatedGlossaryNameIsNotEmpty() {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " is not null AND " +
                IProductGlossaryRelateDAO.RelatedGlossaryName + " <> ''");

            return this;
        }

        public Criteria andRelatedGlossaryNameIsEmpty() {
            addCriterion("(" + IProductGlossaryRelateDAO.RelatedGlossaryName +
                " is null OR " + IProductGlossaryRelateDAO.RelatedGlossaryName +
                " = '')");

            return this;
        }

        public Criteria andRelatedGlossaryNameEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " = ",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameNotEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " <>",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " is null OR " + IProductGlossaryRelateDAO.RelatedGlossaryName +
                " <>", value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " >",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " >=",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThan(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " <",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName + " <=",
                value, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryRelateDAO.RelatedGlossaryName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRelatedGlossaryNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " like", buffer.toString(), "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " not like", buffer.toString(), "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedGlossaryNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                    " in", values, "relatedGlossaryName");

                return this;
            }
        }

        public Criteria andRelatedGlossaryNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRelatedGlossaryNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                    " not in", values, "relatedGlossaryName");

                return this;
            }
        }

        public Criteria andRelatedGlossaryNameIn(String[] values) {
            if (values.length == 1) {
                return andRelatedGlossaryNameEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                    " in", Arrays.asList(values), "relatedGlossaryName");

                return this;
            }
        }

        public Criteria andRelatedGlossaryNameNotIn(String[] values) {
            if (values.length == 1) {
                return andRelatedGlossaryNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                    " not in", Arrays.asList(values), "relatedGlossaryName");

                return this;
            }
        }

        public Criteria andRelatedGlossaryNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRelatedGlossaryNameBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " between", value1, value2, "relatedGlossaryName");

            return this;
        }

        public Criteria andRelatedGlossaryNameNotBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryRelateDAO.RelatedGlossaryName +
                " not between", value1, value2, "relatedGlossaryName");

            return this;
        }
    }
}
